Web Development AtomicReference: গাইড ও নোট

AtomicReference হল Java এবং অনুরূপ মাল্টি-থ্রেডেড প্রোগ্রামিং ভাষায় ব্যবহৃত একটি বিশেষ শ্রেণি (class) যা একটি অবজেক্টকে থ্রেড-সেফ (thread-safe) পদ্ধতিতে অ্যাক্সেস ও আপডেট করতে দেয়। এটি মূলত atomic operations এর মাধ্যমে ডেটার স্থিতিশীলতা (consistency) বজায় রাখে এবং মাল্টি-থ্রেডিংয়ের সময় race condition প্রতিরোধ করে।

AtomicReference কেন ব্যবহার করা হয়?

একাধিক থ্রেড যখন একই অবজেক্টে কাজ করে এবং সেই অবজেক্টের মান (value) আপডেট করতে চায়, তখন synchronization ছাড়া এই পরিবর্তন করা ঝুঁকিপূর্ণ। AtomicReference ব্যবহার করলে নিম্নলিখিত সুবিধাগুলো পাওয়া যায়:

1. Thread-Safe Operations: একাধিক থ্রেড একসাথে কাজ করলেও ডেটা সঠিক থাকে।
2. Non-blocking Mechanism: লক বা মিউটেক্স (mutex) ব্যবহার ছাড়াই কাজ সম্পন্ন হয়।
3. CAS (Compare-And-Swap): একটি নির্দিষ্ট মানের উপর ভিত্তি করে ডেটা আপডেট করা হয়।

AtomicReference কীভাবে কাজ করে?

AtomicReference একটি অবজেক্টের রেফারেন্স ধরে রাখে এবং এর মান থ্রেড-সেফ উপায়ে পড়া ও পরিবর্তন করার জন্য বিভিন্ন পদ্ধতি প্রদান করে। এটি মূলত Compare-And-Swap (CAS) অ্যালগরিদমের উপর ভিত্তি করে কাজ করে।

CAS-এর ধারণা:

• একটি current value এবং একটি expected value এর তুলনা করা হয়।
• যদি current value expected value এর সমান হয়, তবে একটি নতুন মান সেট করা হয়।
• যদি সমান না হয়, তবে অপারেশন বাতিল করা হয়।

AtomicReference এর প্রধান মেথড

1. get()
   বর্তমান রেফারেন্স রিটার্ন করে।
   উদাহরণ:

   AtomicReference<String> ref = new AtomicReference<>("Initial Value");
   System.out.println(ref.get()); // আউটপুট: Initial Value
   

2. set(newValue)
   নতুন মান দিয়ে রেফারেন্স আপডেট করে।
   উদাহরণ:

   ref.set("Updated Value");
   System.out.println(ref.get()); // আউটপুট: Updated Value
   

3. compareAndSet(expectedValue, newValue)
   রেফারেন্সের বর্তমান মান যদি expectedValue এর সমান হয়, তবে এটি newValue দিয়ে আপডেট হয়।
   উদাহরণ:

   boolean updated = ref.compareAndSet("Initial Value", "New Value");
   System.out.println(updated); // আউটপুট: false (কারণ মানটি Initial Value নয়)
   

4. getAndSet(newValue)
   নতুন মান সেট করার আগে পুরানো মান রিটার্ন করে।
   উদাহরণ:

   String oldValue = ref.getAndSet("Final Value");
   System.out.println(oldValue); // আউটপুট: Updated Value
   System.out.println(ref.get()); // আউটপুট: Final Value
   

5. weakCompareAndSet(expectedValue, newValue)
   compareAndSet এর মতোই কাজ করে, তবে এটি দুর্বল গ্যারান্টি (weaker guarantees) প্রদান করে এবং পুনরায় চেষ্টা করে না।

AtomicReference উদাহরণ

১. Basic Example

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> ref = new AtomicReference<>("Hello");

        // মান পড়া
        System.out.println("Initial Value: " + ref.get());

        // মান আপডেট করা
        ref.set("World");
        System.out.println("Updated Value: " + ref.get());

        // Compare-And-Swap (CAS) ব্যবহার
        boolean isUpdated = ref.compareAndSet("Hello", "Atomic");
        System.out.println("CAS Result: " + isUpdated); // false

        // পুনরায় CAS ব্যবহার
        isUpdated = ref.compareAndSet("World", "Atomic");
        System.out.println("CAS Result: " + isUpdated); // true
        System.out.println("Final Value: " + ref.get());
    }
}

২. মাল্টি-থ্রেডিং এর ক্ষেত্রে AtomicReference

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceThreadSafe {
    public static void main(String[] args) {
        AtomicReference<Integer> counter = new AtomicReference<>(0);

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.updateAndGet(value -> value + 1); // Atomic increment
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Counter Value: " + counter.get()); // 2000
    }
}

AtomicReference এর সুবিধা

1. Thread-safe Object Handling: একই অবজেক্টে একাধিক থ্রেড কাজ করতে পারে।
2. Non-blocking: লক ছাড়া কার্যকর অপারেশন সম্ভব।
3. CAS অ্যালগরিদম ব্যবহার: ডেটা আপডেটের সময় সঠিকতা বজায় থাকে।
4. Simple API: জটিল সিঙ্ক্রোনাইজেশন কোডের পরিবর্তে সহজ মেথড প্রদান করে।

AtomicReference এর সীমাবদ্ধতা

1. Complexity in Nested Structures: গভীর বা নেস্টেড অবজেক্টের জন্য এটি কম কার্যকর।
2. CAS Overhead: বারবার তুলনা করার কারণে পারফরম্যান্স কমতে পারে।
3. Memory Consumption: অতিরিক্ত রেফারেন্স মেমোরি খরচ করে।

উপসংহার

AtomicReference হল মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের জন্য একটি গুরুত্বপূর্ণ টুল যা থ্রেড-সেফ উপায়ে ডেটা ম্যানিপুলেট করতে সাহায্য করে। এটি মূলত non-blocking operations এবং CAS mechanism এর মাধ্যমে ডেটা কনসিস্টেন্সি বজায় রাখে, যা জটিল মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলোর কার্যকারিতা বৃদ্ধি করে।

AtomicReference হল Java-এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস যা reference types এর উপর atomic operations সম্পাদন করতে ব্যবহৃত হয়। এটি একাধিক থ্রেডের মধ্যে reference variables (যেমন, objects, arrays, etc.) নিরাপদভাবে পরিচালনা করতে সাহায্য করে এবং thread safety নিশ্চিত করে।

এটি একটি generic class যা ডেটা টাইপের উপর কাজ করতে সক্ষম, এবং একই সময়ে একাধিক থ্রেড দ্বারা অ্যাক্সেস বা পরিবর্তন করা হলে ডেটার সঠিকতা এবং নিরাপত্তা বজায় রাখে।

AtomicReference এর মূল ধারণা

• Atomic Operations: AtomicReference প্রতিটি অপারেশনকে atomic বা indivisible (অখণ্ড) বানায়, অর্থাৎ কোনো অপারেশন চলাকালীন অন্য কোনো থ্রেড তার মধ্যে হস্তক্ষেপ করতে পারে না।
• Thread Safety: একাধিক থ্রেড একই reference variable অ্যাক্সেস বা পরিবর্তন করলেও ডেটা সঠিক থাকে।
• Generics Support: AtomicReference যেকোনো object reference টাইপের জন্য ব্যবহৃত হতে পারে, যেমন String, Custom Classes, Lists, Maps, ইত্যাদি।

AtomicReference এর বৈশিষ্ট্য

• Thread-Safe Reference Management: একাধিক থ্রেড যখন একই রেফারেন্স ভ্যারিয়েবলে কাজ করে, তখন এটি ডেটা সুরক্ষিত রাখে।
• Atomicity: এটি atomic operations সরবরাহ করে, যা অপারেশন চলাকালীন থ্রেডের মধ্যে হস্তক্ষেপ রোধ করে।
• Non-blocking: লক (lock) বা মিউটেক্স (mutex) ছাড়া কাজ করা যায়, যার ফলে পারফরম্যান্স উন্নত হয়।
• Compare-and-Set (CAS): এটি atomic compare-and-set অপারেশন সরবরাহ করে, যেখানে একটি থ্রেড একটি রেফারেন্স ভ্যালুকে নতুন ভ্যালু দিয়ে প্রতিস্থাপন করতে পারে, যদি সেটি একটি প্রত্যাশিত মানের সমান হয়।

AtomicReference এর মেথডসমূহ

১. get()

এটি বর্তমান রেফারেন্স ভ্যালু রিটার্ন করে।

T currentValue = atomicReference.get();

২. set(T newValue)

এটি নতুন মান সেট করে।

atomicReference.set(newValue);

৩. compareAndSet(T expected, T newValue)

যদি বর্তমান মান expected এর সমান হয়, তবে এটি newValue দিয়ে আপডেট করে। এটি একটি atomic check-and-set অপারেশন।

boolean isUpdated = atomicReference.compareAndSet(expected, newValue);

৪. getAndSet(T newValue)

এটি বর্তমান মানটি রিটার্ন করে এবং নতুন মান সেট করে।

T oldValue = atomicReference.getAndSet(newValue);

৫. weakCompareAndSet(T expected, T newValue)

compareAndSet এর মতো, তবে এটি একটি অস্থায়ী (weak) সিঙ্ক্রোনাইজেশন ব্যবস্থার মাধ্যমে কাজ করে। এটি পারফরম্যান্সের জন্য উপকারী হতে পারে।

AtomicReference এর ব্যবহার

১. স্টেট পরিবর্তন ট্র্যাকিং (State Change Tracking)

ধরা যাক, একটি অ্যাপ্লিকেশনে একটি নির্দিষ্ট অবস্থা ট্র্যাক করতে হবে যা একাধিক থ্রেড দ্বারা পরিবর্তিত হতে পারে। AtomicReference ব্যবহার করে এই ধরনের স্টেট ম্যানেজমেন্ট করা যায়।

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> reference = new AtomicReference<>("Initial Value");

        // get() ব্যবহার করে মান পড়া
        System.out.println("Current Value: " + reference.get()); // Output: Initial Value

        // set() ব্যবহার করে নতুন মান সেট করা
        reference.set("Updated Value");
        System.out.println("Updated Value: " + reference.get()); // Output: Updated Value

        // compareAndSet() ব্যবহার করে atomic update করা
        boolean wasUpdated = reference.compareAndSet("Updated Value", "New Value");
        System.out.println("Was updated: " + wasUpdated); // Output: true
        System.out.println("Final Value: " + reference.get()); // Output: New Value
    }
}

২. থ্রেড সিঙ্ক্রোনাইজেশন

একাধিক থ্রেড একযোগে একই রেফারেন্স মান পরিবর্তন করার সময়, AtomicReference ব্যবহার করা হলে race condition এড়ানো সম্ভব হয় এবং ডেটার সঠিকতা নিশ্চিত হয়।

import java.util.concurrent.atomic.AtomicReference;

public class ThreadSafetyExample {
    private static final AtomicReference<Integer> counter = new AtomicReference<>(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> increment());
        Thread t2 = new Thread(() -> increment());

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final Counter: " + counter.get());
    }

    private static void increment() {
        int currentValue;
        do {
            currentValue = counter.get();
        } while (!counter.compareAndSet(currentValue, currentValue + 1));
    }
}

AtomicReference এর সুবিধা

• Thread Safety: একাধিক থ্রেড ডেটা অ্যাক্সেস করার সময় ডেটা সঠিক থাকে।
• High Performance: লক-মুক্ত (lock-free) অপারেশন পারফরম্যান্স বাড়ায়।
• Atomic Operations: প্রতিটি অপারেশন indivisible হওয়ায় race condition প্রতিরোধ করা যায়।
• Generics Support: এটি যেকোনো object reference টাইপের জন্য ব্যবহৃত হতে পারে, যেমন String, Integer, Custom Objects, ইত্যাদি।

AtomicReference এর সীমাবদ্ধতা

• Reference Types Only: এটি শুধুমাত্র reference types এর জন্য কাজ করে, প্রিমিটিভ টাইপের জন্য নয়।
• Atomicity of Reference: এটি কেবলমাত্র রেফারেন্স (object) এর মান পরিবর্তন নিশ্চিত করে, কিন্তু deep equality বা shallow copy এর মধ্যে পার্থক্য করতে পারে না।
• Limited Scope: যখন খুব বেশি সংখ্যক থ্রেড একসঙ্গে একে অপরের সাথে কাজ করছে, তখন AtomicReference এর কর্মক্ষমতা প্রভাবিত হতে পারে।

উপসংহার

AtomicReference হল একটি অত্যন্ত কার্যকর টুল যা thread-safe reference type ডেটা পরিচালনা করার জন্য ব্যবহৃত হয়। এটি atomic অপারেশন সরবরাহ করে, যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটার সঠিকতা এবং নিরাপত্তা নিশ্চিত করতে সহায়ক। এটি Generics এর সমর্থন দিয়ে ডেভেলপারদের আরো নমনীয়তা প্রদান করে, বিশেষ করে যখন custom objects বা complex data structures ব্যবহৃত হয়।

AtomicReference হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ক্লাস, যা একটি অবিভাজ্য (atomic) এবং থ্রেড-সেফ উপায়ে Object References পরিচালনা করতে ব্যবহৃত হয়। এটি জেনেরিক্স (Generics) সমর্থন করে, যার ফলে বিভিন্ন ধরণের অবজেক্ট রেফারেন্সের উপর কাজ করা যায়।

AtomicReference বিশেষত মাল্টি-থ্রেডেড অ্যাপ্লিকেশনে ব্যবহৃত হয়, যেখানে একাধিক থ্রেড একটি শেয়ার করা অবজেক্টকে atomic ভাবে আপডেট করতে পারে।

AtomicReference কীভাবে কাজ করে?

1. Object Reference Management:
   AtomicReference একটি অবজেক্ট রেফারেন্সকে পরিচালনা করে। এটি CAS (Compare-and-Swap) মেকানিজম ব্যবহার করে রেফারেন্স আপডেট করে।
2. Generics Support:
   এটি জেনেরিক্স সমর্থন করে, যার ফলে এটি যেকোনো ধরণের অবজেক্টের জন্য ব্যবহার করা যায়। যেমন AtomicReference<String>, AtomicReference<MyClass>।
3. Thread Safety:
   থ্রেডগুলোর মধ্যে অবজেক্ট রেফারেন্স আপডেট করার সময় race condition প্রতিরোধ করে।

AtomicReference এর প্রধান মেথডসমূহ

১. get():

• রেফারেন্সকৃত অবজেক্টটি রিটার্ন করে।
• থ্রেড-সেফ পদ্ধতিতে রেফারেন্স পড়ার জন্য ব্যবহৃত হয়।

২. set(T newValue):

• একটি নতুন অবজেক্ট রেফারেন্স সেট করে।
• এটি থ্রেড-সেফ নয়, তবে এটি সরল উপায়ে রেফারেন্স আপডেট করতে পারে।

৩. compareAndSet(T expectedValue, T newValue):

• যদি বর্তমান রেফারেন্সটি expectedValue এর সমান হয়, তবে এটি newValue দিয়ে আপডেট হয়।
• এটি একটি atomic অপারেশন এবং race condition এড়াতে কার্যকর।

৪. getAndSet(T newValue):

• রেফারেন্সটি একটি নতুন মান দিয়ে আপডেট করে এবং পুরোনো মানটি রিটার্ন করে।

৫. weakCompareAndSet(T expectedValue, T newValue):

• compareAndSet এর মতো কাজ করে, তবে এটি guarantee দেয় না যে অপারেশনটি সব সময় সফল হবে।

Generics এর সাথে AtomicReference ব্যবহার

AtomicReference জেনেরিক্স ব্যবহার করে যেকোনো ধরনের অবজেক্ট পরিচালনা করতে পারে। উদাহরণস্বরূপ, আপনি String, Integer, বা কোনো Custom Class এর রেফারেন্স রাখতে পারেন।

উদাহরণ: String রেফারেন্স ম্যানেজমেন্ট

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    public static void main(String[] args) {
        AtomicReference<String> atomicString = new AtomicReference<>("Initial Value");

        // Get the current value
        System.out.println("Current Value: " + atomicString.get());

        // Set a new value
        atomicString.set("Updated Value");
        System.out.println("Updated Value: " + atomicString.get());

        // Compare and set
        boolean success = atomicString.compareAndSet("Updated Value", "Final Value");
        System.out.println("Compare-And-Set Success: " + success);
        System.out.println("Final Value: " + atomicString.get());
    }
}

আউটপুট:

Current Value: Initial Value
Updated Value: Updated Value
Compare-And-Set Success: true
Final Value: Final Value

Object References এর সাথে ব্যবহার

উদাহরণ: Custom Object ব্যবহার

import java.util.concurrent.atomic.AtomicReference;

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }
}

public class Main {
    public static void main(String[] args) {
        AtomicReference<Person> atomicPerson = new AtomicReference<>(new Person("Alice"));

        // Get the current object
        System.out.println("Current Person: " + atomicPerson.get());

        // Update the reference
        atomicPerson.set(new Person("Bob"));
        System.out.println("Updated Person: " + atomicPerson.get());

        // Compare and Set
        boolean success = atomicPerson.compareAndSet(new Person("Bob"), new Person("Charlie"));
        System.out.println("Compare-And-Set Success: " + success); // false, because "Bob" is a different instance

        success = atomicPerson.compareAndSet(atomicPerson.get(), new Person("Charlie"));
        System.out.println("Compare-And-Set Success: " + success);
        System.out.println("Final Person: " + atomicPerson.get());
    }
}

আউটপুট:

Current Person: Person{name='Alice'}
Updated Person: Person{name='Bob'}
Compare-And-Set Success: false
Compare-And-Set Success: true
Final Person: Person{name='Charlie'}

AtomicReference এর সুবিধা

• Thread Safety: এটি থ্রেড-সেফ উপায়ে অবজেক্ট রেফারেন্স ম্যানেজ করতে পারে।
• Race Condition প্রতিরোধ: একাধিক থ্রেডের মধ্যে ডেটা আপডেট করার সময় সমস্যা এড়ানো।
• Generics Support: এটি যেকোনো ধরণের অবজেক্ট রেফারেন্স পরিচালনা করতে পারে।
• Non-blocking Mechanism: লক ছাড়াই atomicity নিশ্চিত করে।

AtomicReference এর সীমাবদ্ধতা

• CAS Overhead: compareAndSet এর বারবার ব্যর্থ অপারেশন কিছু ক্ষেত্রে পারফরম্যান্স সমস্যা সৃষ্টি করতে পারে।
• Complex Logic: অনেক বড় অবজেক্ট বা জটিল লজিক পরিচালনা করা তুলনামূলক কঠিন।
• Immutable References: রেফারেন্সে Immutable ডেটা ব্যবহার করাই উত্তম; Mutable ডেটা ব্যবহারে সমস্যা বাড়তে পারে।

AtomicReference এর ব্যবহার ক্ষেত্র

1. Immutable Data Management: Immutable অবজেক্টের রেফারেন্স থ্রেড-সেফ উপায়ে পরিচালনা করা।
2. Shared Resource Coordination: মাল্টি-থ্রেডিংয়ে শেয়ার করা রিসোর্স পরিচালনা।
3. Non-blocking Algorithms: ব্লকিং ছাড়াই থ্রেডের মধ্যে সমন্বয় বজায় রাখা।
4. Custom Lock Implementation: লাইটওয়েট লক মেকানিজম তৈরি।

উপসংহার

AtomicReference একটি কার্যকর টুল যা multithreaded programming-এ শেয়ার করা অবজেক্টের রেফারেন্স ম্যানেজ করার জন্য ব্যবহৃত হয়। এটি থ্রেড-সেফ, জেনেরিক্স সমর্থিত এবং লক-মুক্ত হওয়ার কারণে মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলোতে ডেটা আপডেট এবং সিঙ্ক্রোনাইজেশনে গুরুত্বপূর্ণ ভূমিকা পালন করে।

AtomicReference হল Java বা মাল্টি-থ্রেডিং পরিবেশে ব্যবহৃত একটি ক্লাস, যা reference object এর মান atomic (অখণ্ড) অপারেশনের মাধ্যমে আপডেট করতে দেয়। এটি মূলত CAS (Compare-And-Swap) মেকানিজমের উপর ভিত্তি করে কাজ করে। AtomicReference একাধিক থ্রেডের মধ্যে ডেটার সঠিকতা এবং সিঙ্ক্রোনাইজেশন নিশ্চিত করতে ব্যবহৃত হয়।

AtomicReference এর কাজ

• Atomicity: সমস্ত অপারেশন (যেমন: রিড, রাইট, আপডেট) একত্রে বা indivisible উপায়ে সম্পন্ন হয়।
• Thread-Safety: একাধিক থ্রেড একই রেফারেন্স ভ্যালুর উপর কাজ করলেও ডেটা সঠিক থাকে।
• Lock-Free Mechanism: লক ব্যবহারের প্রয়োজন হয় না, ফলে পারফরম্যান্স বৃদ্ধি পায়।

AtomicReference এর গুরুত্বপূর্ণ Methods

১. get()

• বর্তমান রেফারেন্স মানটি রিটার্ন করে।

• Syntax:

  public V get()
  

• উদাহরণ:

  AtomicReference<String> atomicRef = new AtomicReference<>("Initial Value");
  System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Initial Value
  

২. set(V newValue)

• রেফারেন্স মানটি সরাসরি আপডেট করে।

• Syntax:

  public void set(V newValue)
  

• উদাহরণ:

  atomicRef.set("Updated Value");
  System.out.println("Updated Value: " + atomicRef.get()); // আউটপুট: Updated Value
  

৩. compareAndSet(V expectedValue, V newValue)

• CAS (Compare-And-Swap) অপারেশনের মাধ্যমে রেফারেন্স মান আপডেট করে।
• বর্তমান মান expectedValue এর সমান হলে এটি newValue দিয়ে আপডেট হয়।

• Syntax:

  public boolean compareAndSet(V expectedValue, V newValue)
  

• উদাহরণ:

  boolean isUpdated = atomicRef.compareAndSet("Initial Value", "New Value");
  System.out.println("Was Updated: " + isUpdated); // আউটপুট: true
  System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: New Value
  

৪. getAndSet(V newValue)

• বর্তমান রেফারেন্স মানটি রিটার্ন করে এবং নতুন মান দিয়ে আপডেট করে।

• Syntax:

  public V getAndSet(V newValue)
  

• উদাহরণ:

  String oldValue = atomicRef.getAndSet("Another Value");
  System.out.println("Old Value: " + oldValue); // আউটপুট: New Value
  System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Another Value
  

৫. weakCompareAndSet(V expectedValue, V newValue)

• একটি দুর্বল বা সম্ভাব্য compare-and-set অপারেশন সম্পন্ন করে। এটি সফল হতে পারে বা ব্যর্থ হতে পারে।

• Syntax:

  public boolean weakCompareAndSet(V expectedValue, V newValue)
  

৬. accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction)

• নির্দিষ্ট একটি accumulator function ব্যবহার করে মানটি আপডেট করে।

• Syntax:

  public V accumulateAndGet(V x, BinaryOperator<V> accumulatorFunction)
  

• উদাহরণ:

  AtomicReference<Integer> atomicInt = new AtomicReference<>(10);
  atomicInt.accumulateAndGet(5, (current, update) -> current + update); 
  System.out.println("Accumulated Value: " + atomicInt.get()); // আউটপুট: 15
  

৭. updateAndGet(UnaryOperator<V> updateFunction)

• একটি UnaryOperator ব্যবহার করে বর্তমান মানটি আপডেট করে এবং নতুন মান রিটার্ন করে।

• Syntax:

  public V updateAndGet(UnaryOperator<V> updateFunction)
  

• উদাহরণ:

  atomicRef.updateAndGet(value -> value + " Updated Again");
  System.out.println("Current Value: " + atomicRef.get()); // আউটপুট: Another Value Updated Again
  

AtomicReference উদাহরণ

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {
    public static void main(String[] args) {
        AtomicReference<String> atomicRef = new AtomicReference<>("Initial Value");

        // get() Method
        System.out.println("Initial Value: " + atomicRef.get());

        // set() Method
        atomicRef.set("Updated Value");
        System.out.println("After Set: " + atomicRef.get());

        // compareAndSet() Method
        boolean wasUpdated = atomicRef.compareAndSet("Updated Value", "New Value");
        System.out.println("Was Updated: " + wasUpdated);
        System.out.println("Current Value: " + atomicRef.get());

        // getAndSet() Method
        String oldValue = atomicRef.getAndSet("Final Value");
        System.out.println("Old Value: " + oldValue);
        System.out.println("Current Value: " + atomicRef.get());
    }
}

AtomicReference এর সুবিধা

1. Thread Safety: একাধিক থ্রেডের মধ্যে ডেটার সঠিকতা নিশ্চিত করে।
2. Lock-Free Synchronization: লক ছাড়া ডেটা সিঙ্ক্রোনাইজ করে, যা পারফরম্যান্স উন্নত করে।
3. CAS মেকানিজম: Compare-And-Swap এর মাধ্যমে ডেটা হস্তক্ষেপ প্রতিরোধ করে।
4. Concurrent Programming সহজ করে।

AtomicReference এর সীমাবদ্ধতা

1. Complexity: বড় ডেটাসেট বা জটিল ডেটা স্ট্রাকচারের জন্য কার্যকর নয়।
2. CPU Overhead: CAS অপারেশন বারবার ব্যর্থ হলে spinning ঘটতে পারে, যা CPU চক্র অপচয় করে।
3. Limited Scope: শুধুমাত্র একক রেফারেন্স মান ম্যানেজ করে।

উপসংহার

AtomicReference হল মাল্টি-থ্রেডিং পরিবেশে ডেটার উপর কাজ করার একটি অত্যন্ত কার্যকর টুল। এটি thread-safe operations পরিচালনা করতে সক্ষম এবং CAS মেকানিজম ব্যবহার করে ডেটা সঠিকতা বজায় রাখে। ছোট স্কেলের synchronization problems সমাধানের জন্য এটি একটি আদর্শ সমাধান।